Discovering Aggregate Implementation Patterns and Event-Sourcing via "Code Koans"

(This is a hands-on lab with limited capacity)

There are many ways to implement the Aggregate pattern from Domain-Driven Design:

• OOP style or functional style
• Traditional or event-sourced
• Internal state, external state, on-the-fly state (reconstituted inside the aggregate)
• Reconstitute the full state or just the minimal state needed to make decisions
• Recording changes or returning changes

Many variations are possible, especially with event-sourced aggregates. I recently played with a functional, event-sourced, minimal, on-the-fly state combination which is a good fit for a prototype phase and this is one of or variations in the workshop. The different use-cases don't share any code, so the Aggregate is reduced to a concept.

We will discover as many of those variations as possible during the workshop, but we will focus on the event-sourced variations, which are much more interesting for our simple example.

Attendees will implement different versions of the same Aggregate in a "Code Koans" like fashion. For each variation, there will be test cases and a skeleton that has to be filled with the missing code to make the tests green. Some variations will have "bonus challenges" where test cases will have to be extended first.

What you will discover:

• different styles of implementing an Aggregate
• how you can implement a conceptual Aggregate without having a big "object"
• the basics of event-sourcing
• a light version of ensemble (mob) programming
• the idea of "Code Koans"

We will supply Git repositories containing Java and Kotlin code. Attendees need a laptop with an IDE that is suitable for Java/Kotlin and should have JUnit installed. https://github.com/MaibornWolff/aggregate-implementation-patterns-java https://github.com/klimisa/aggregate-implementation-patterns-csharp https://github.com/MaibornWolff/aggregate-implementation-patterns-kotlin

Senior IT Architect @ MaibornWolffTwitter

IT Architect @ MaibornWolff